home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk10.zip / FIELD.C < prev    next >
C/C++ Source or Header  |  1991-10-05  |  11KB  |  446 lines
  1.  
  2. /********************************************
  3. field.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13. /* $Log:    field.c,v $
  14.  * Revision 3.5.1.1  91/09/14  17:23:11  brennan
  15.  * VERSION 1.0
  16.  * 
  17.  * Revision 3.5  91/08/13  06:51:16  brennan
  18.  * VERSION .9994
  19.  * 
  20.  * Revision 3.4  91/07/17  15:11:39  brennan
  21.  * pass length of s to space_split
  22.  * 
  23.  * Revision 3.3  91/06/28  04:16:35  brennan
  24.  * VERSION 0.999
  25.  * 
  26.  * Revision 3.2  91/06/24  10:05:27  brennan
  27.  * FS="" and $0="", gave NF=1 should be 0
  28.  * 
  29.  * Revision 3.1  91/06/07  10:27:22  brennan
  30.  * VERSION 0.995
  31.  * 
  32.  * Revision 2.6  91/05/28  15:17:46  brennan
  33.  * removed STRING_BUFF back to temp_buff.string_buff
  34.  * 
  35.  * Revision 2.5  91/05/28  09:04:42  brennan
  36.  * removed main_buff
  37.  * 
  38.  * Revision 2.4  91/05/08  12:23:17  brennan
  39.  * RS = "" is now the same as RS = "\n\n+"
  40.  * 
  41.  * Revision 2.3  91/04/24  13:49:56  brennan
  42.  * eliminated unnecessary calculation of fields in field_assign()
  43.  * 
  44.  * Revision 2.2  91/04/09  12:39:00  brennan
  45.  * added static to funct decls to satisfy STARDENT compiler
  46.  * 
  47.  * Revision 2.1  91/04/08  08:23:01  brennan
  48.  * VERSION 0.97
  49.  * 
  50. */
  51.  
  52.  
  53. /* field.c */
  54.  
  55. #include "mawk.h"
  56. #include "field.h"
  57. #include "init.h"
  58. #include "memory.h"
  59. #include "scan.h"
  60. #include "bi_vars.h"
  61. #include "repl.h"
  62. #include "regexp.h"
  63.  
  64. union tbuff  temp_buff ;
  65. CELL  field[NUM_FIELDS] ;
  66.  
  67. /* statics */
  68. static void PROTO( build_field0, (void) ) ;
  69. static void PROTO( xcast, (CELL *) ) ;
  70. static void PROTO( set_rs_shadow, (void) ) ;
  71.  
  72. /* the order is important here, must be the same as
  73.    postion after field[MAX_FIELD] */
  74.  
  75. static char *biv_field_names[] = {
  76. "NF" , "RS" , "FS", "OFMT" } ;
  77.  
  78. /* a description of how to split based on RS.
  79.    If RS is changed, so is rs_shadow */
  80. SEPARATOR rs_shadow = {SEP_CHAR, '\n'} ;
  81. /* a splitting CELL version of FS */
  82. CELL fs_shadow = {C_SPACE} ;
  83. int   nf ;  
  84.   /* nf holds the true value of NF.  If nf < 0 , then
  85.      NF has not been computed, i.e., $0 has not been split
  86.   */
  87.  
  88. static void set_rs_shadow()
  89. { CELL c ;
  90.   STRING  *sval ;
  91.   char *s ;
  92.   unsigned len ;
  93.  
  94.   if ( rs_shadow.type == SEP_STR )  free_STRING((STRING*) rs_shadow.ptr) ;
  95.  
  96.   cast_for_split( cellcpy(&c, field+RS) ) ;
  97.   switch( c.type )
  98.   {
  99.     case C_RE :
  100.         if ( s = is_string_split(c.ptr, &len) )
  101.             if ( len == 1 )
  102.             { rs_shadow.type = SEP_CHAR ;
  103.               rs_shadow.c = s[0] ;
  104.             }
  105.             else
  106.             { rs_shadow.type = SEP_STR ;
  107.               rs_shadow.ptr = (PTR) new_STRING(s) ;
  108.             }
  109.         else
  110.         { rs_shadow.type = SEP_RE ;
  111.           rs_shadow.ptr = c.ptr ;
  112.         }
  113.         break ;
  114.  
  115.     case C_SPACE :
  116.         rs_shadow.type = SEP_CHAR ;
  117.         rs_shadow.c = ' ' ;
  118.         break ;
  119.  
  120.     case C_SNULL : /* RS becomes one or more blank lines */
  121.         rs_shadow.type = SEP_RE ;
  122.         sval = new_STRING( "\n\n+" ) ;
  123.         rs_shadow.ptr = re_compile(sval) ;
  124.         free_STRING(sval) ;
  125.         break ;
  126.  
  127.     default : bozo("bad cell in set_rs_shadow") ;
  128.   }
  129. }
  130.  
  131. void  field_init()
  132. { char **p = biv_field_names ;
  133.   SYMTAB *st_p ;
  134.   int i ;
  135.  
  136.   for(i = NF  ; i < NUM_FIELDS ; p++ , i++ )
  137.   {
  138.     st_p = insert( *p ) ;
  139.     st_p->type = ST_FIELD ;
  140.     st_p->stval.cp = &field[i] ;
  141.   }
  142.  
  143.   field[NF].type = C_DOUBLE ;
  144.   field[NF].dval = 0.0 ;
  145.   field[0].type = C_STRING ;
  146.   field[0].ptr = (PTR) & null_str ;
  147.   null_str.ref_cnt++ ;
  148.  
  149.   field[RS].type = C_STRING ;
  150.   field[RS].ptr =  (PTR) new_STRING( "\n" ) ;
  151.   /* rs_shadow already set */
  152.  
  153.   field[FS].type = C_STRING ;
  154.   field[FS].ptr = (PTR) new_STRING( " " ) ;
  155.   /* fs_shadow is already set */
  156.  
  157.   field[OFMT].type = C_STRING ;
  158.   field[OFMT].ptr = (PTR) new_STRING( "%.6g" ) ;
  159. }
  160.  
  161.  
  162.  
  163. void  set_field0( s, len)
  164.   char *s ;
  165.   unsigned len ;
  166. { 
  167.   cell_destroy( & field[0] ) ;
  168.   nf = -1 ;
  169.  
  170.   if ( len )
  171.   {
  172.     field[0].type = C_MBSTRN ;
  173.     field[0].ptr = (PTR) new_STRING( (char *) 0, len) ;
  174.     (void) memcpy( string(&field[0])->str, s, SIZE_T(len) ) ;
  175.   }
  176.   else
  177.   {
  178.     field[0].type = C_STRING ;
  179.     field[0].ptr = (PTR) &null_str ;
  180.     null_str.ref_cnt++ ;
  181.   }
  182. }
  183.  
  184.  
  185.  
  186. /* split field[0] into $1, $2 ... and set NF  */
  187.  
  188. void  split_field0()
  189. { register CELL *cp ;
  190.   register int i ;
  191.   CELL  c ;  /* copy field[0] here if not string */
  192.  
  193.  
  194.   if ( field[0].type < C_STRING )
  195.   { cast1_to_s(cellcpy(&c, field+0)) ;
  196.     cp = &c ;
  197.   }
  198.   else   cp = &field[0] ;
  199.  
  200.   if ( string(cp)->len == 0 )  nf = 0 ;
  201.   else
  202.   {
  203.     switch( fs_shadow.type )
  204.     {
  205.       case   C_SNULL :  /* FS == "" */
  206.       nf = 1 ;
  207.       cell_destroy(field+NF) ;
  208.       field[NF].type = C_DOUBLE ;
  209.       field[NF].dval = 1.0 ;
  210.       field[1].type = C_MBSTRN ;
  211.       field[1].ptr = cp->ptr ;
  212.  
  213.       if ( cp == field )  string(cp)->ref_cnt++ ;
  214.       /* else we gain one ref_cnt and lose one for a wash */
  215.  
  216.       return ;
  217.  
  218.       case  C_SPACE :
  219.       nf = space_split(string(cp)->str, string(cp)->len) ;
  220.       break ;
  221.  
  222.       default :
  223.       nf = re_split(string(cp)->str, fs_shadow.ptr) ;
  224.       break ;
  225.     }
  226.         
  227.     if ( nf > MAX_FIELD )
  228.         rt_overflow("maximum number of fields", MAX_FIELD) ;
  229.   }
  230.   
  231.   cell_destroy(field+NF) ;
  232.   field[NF].type = C_DOUBLE ;
  233.   field[NF].dval = (double) nf ;
  234.  
  235.   for( i = 1 ; i <= nf ; i++ )
  236.   {
  237.     cell_destroy(field+i) ;
  238.     field[i].ptr = temp_buff.ptr_buff[i-1] ;
  239.     field[i].type = C_MBSTRN ;
  240.   }
  241.  
  242.   if ( cp == &c )  free_STRING( string(cp) ) ;
  243. }
  244.  
  245. /*
  246.   assign CELL *cp to field[i]
  247.   and take care of all side effects
  248. */
  249.  
  250. void  field_assign( i, cp)
  251.   register int i ;
  252.   CELL *cp ;
  253. { register int j ;
  254.   CELL c ;
  255.  
  256.   /* update fields not up to date , unless we are
  257.      assigning to $0 */
  258.   if ( i != 0 && nf < 0 )  split_field0() ;
  259.  
  260.   switch( i )
  261.   {
  262.     case 0 :
  263.         cell_destroy(field) ;
  264.         nf = -1 ;
  265.         (void) cellcpy(field, cp) ;
  266.         break ; ;
  267.  
  268.     case  NF :
  269.         cell_destroy(field+NF) ;
  270.         (void) cellcpy(field+NF, cellcpy(&c,cp) ) ;
  271.         if ( c.type != C_DOUBLE )  cast1_to_d(&c) ;
  272.  
  273.         if ( (j = (int) c.dval) < 0 )
  274.             rt_error("negative value assigned to NF") ;
  275.         if ( j > MAX_FIELD )
  276.             rt_overflow("MAX_FIELD", MAX_FIELD) ;
  277.  
  278.         if ( j > nf )
  279.             for ( i = nf+1 ; i <= j ; i++ )
  280.             { cell_destroy(field+i) ;
  281.               field[i].type = C_STRING ;
  282.               field[i].ptr = (PTR) &null_str ;
  283.               null_str.ref_cnt++ ;
  284.             }
  285.  
  286.         nf = j ;
  287.         build_field0() ;
  288.         break ;
  289.  
  290.     case  RS :
  291.         cell_destroy(field+RS) ;
  292.         (void) cellcpy(field+RS, cp) ;
  293.         set_rs_shadow() ;
  294.         break ;
  295.  
  296.     case  FS :
  297.         cell_destroy(field+FS) ;
  298.         cast_for_split( cellcpy(&fs_shadow, cellcpy(field+FS, cp)) ) ;
  299.         break ;
  300.  
  301.     case OFMT : 
  302.         /* If the user does something stupid with OFMT, we could crash.
  303.            We'll make an attempt to protect ourselves here.  This is
  304.            why OFMT is made a field.
  305.  
  306.            The ptr of OFMT always has a valid STRING, even if assigned
  307.            a DOUBLE or NOINIT
  308.         */
  309.  
  310.         free_STRING( string(field+OFMT) ) ;
  311.         (void) cellcpy(field+OFMT, cp) ;
  312.         if ( field[OFMT].type < C_STRING ) /* !! */
  313.              field[OFMT].ptr = (PTR) new_STRING( "%.6g" ) ;
  314.         else
  315.         {
  316.           /* It's a string, but if it's really goofy it could still
  317.              damage us. Test it . */
  318.           temp_buff.string_buff[256] = 0 ;
  319.           (void) sprintf(temp_buff.string_buff, 
  320.              string(field+OFMT)->str, 3.1459) ;
  321.           if ( temp_buff.string_buff[256] )
  322.                 rt_error("OFMT assigned unusable value") ;
  323.         }
  324.         break ;
  325.            
  326.  
  327.     default:
  328.  
  329. #ifdef DEBUG 
  330.         if ( i < 0 )
  331.             bozo("negative field index in field_assign") ;
  332.         if ( i > MAX_FIELD )
  333.             bozo("large field index in field_assign") ;
  334. #endif
  335.  
  336.         cell_destroy(field+i) ;
  337.         (void) cellcpy(field+i, cp) ;
  338.         if ( i > nf )
  339.         { for ( j = nf+1 ; j < i ; j++ )
  340.           { cell_destroy(field+j) ;
  341.             field[j].type = C_STRING ;
  342.             field[j].ptr = (PTR) &null_str ;
  343.             null_str.ref_cnt++ ;
  344.           }
  345.           nf = i ;
  346.           cell_destroy(field+NF) ;
  347.           field[NF].type = C_DOUBLE ;
  348.           field[NF].dval = (double) i ;
  349.         }
  350.  
  351.         build_field0() ;
  352.  
  353.   }
  354. }
  355.  
  356.  
  357. /* get the string rep of a double without changing its
  358.    type */
  359.  
  360. static void  xcast( cp )
  361.   register CELL *cp ;
  362. {
  363.   switch ( cp->type )
  364.   {
  365.     case C_NOINIT :
  366.         cp->ptr = (PTR) &null_str ;
  367.         null_str.ref_cnt++ ;
  368.         break ;
  369.  
  370.     case C_DOUBLE :
  371.         (void) sprintf(temp_buff.string_buff, 
  372.           string(field+OFMT)->str, cp->dval) ;
  373.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  374.         break ;
  375.   }
  376. }
  377.  
  378.  
  379. /* construct field[0] from the other fields */
  380.  
  381. static void  build_field0()
  382. { 
  383.  
  384.  
  385. #ifdef DEBUG
  386.   if ( nf < 0 )  
  387.       bozo("nf <0 in build_field0") ;
  388. #endif
  389.  
  390.   cell_destroy( field+0 ) ;
  391.  
  392.   if ( nf == 0 )
  393.   { field[0].type = C_STRING ;
  394.     field[0].ptr = (PTR) &null_str ;
  395.     null_str.ref_cnt++ ;
  396.   }
  397.   else
  398.   if ( nf == 1 )  (void) cellcpy(field, field+1) ;
  399.  
  400.   else
  401.   { CELL  ofs ;
  402.     char *ofs_str ;
  403.     unsigned ofs_len , len0 = 0 ;
  404.     register int i ;
  405.     register char *p, *q ;
  406.  
  407.  
  408.     (void) cellcpy(& ofs , bi_vars + OFS) ;
  409.     if ( ofs.type < C_STRING )  cast1_to_s(&ofs) ;
  410.     ofs_str = string(&ofs)->str ;
  411.     ofs_len = string(&ofs)->len ;
  412.  
  413.  
  414.     for( i = 1 ; i <= nf ; i++ )
  415.     {
  416.       if ( field[i].type < C_STRING )  xcast(field+i) ;
  417.       len0 += string(field+i)->len + ofs_len ;
  418.     }
  419.     len0 -= ofs_len ;
  420.  
  421.     field[0].type = C_STRING ;
  422.     field[0].ptr = (PTR) new_STRING((char *) 0, len0) ;
  423.  
  424.     p = string(field)->str ;
  425.     for( i = 1 ; i < nf ; i++ )
  426.     {
  427.       (void) memcpy(p, string(field+i)->str, SIZE_T(string(field+i)->len)) ;
  428.       p += string(field+i)->len ;
  429.  
  430.       /* add the separator */
  431.       q = ofs_str ;
  432.       while ( *p++ = *q++ ) ;  p-- ;
  433.  
  434.       /* if not really string undo the xcast */
  435.       if ( field[i].type < C_STRING )
  436.               free_STRING( string(field+i) ) ;
  437.     }
  438.     /* do the last piece */
  439.     (void) memcpy(p, string(field+i)->str, SIZE_T(string(field+i)->len)) ;
  440.     if ( field[i].type < C_STRING )
  441.               free_STRING( string(field+i) ) ;
  442.     
  443.     free_STRING( string(&ofs) ) ;
  444.   } 
  445. }
  446.